<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        //三目运算符  (比if高端的条件判断，还能返回值)
        //条件判断？  是 ： 否   并且会返回值
        // var num = 1 > 0 ? 2 + 2 : 1 + 1;
        // var num = 条件 ？ 是的话返回 ： 不是的话返回;
        // console.log(num);
        //如果1>0，返回2+2；如果不是的话返回1+1
        //*字符串10小于 字符串 9

        // var num = 1 > 0 ? ('10' > '9' ? 1 : 0) : 2;




        //           数组
        // 数组的定义
        //    new Array(length/content)
        //    字面量  var arr = [];
        // 数组的读和写
        //    arr[num]//不可溢出读  结果是undefined
        //    arr[num]=xxx;//可以溢出写

        // var arr = new Array(10); //给这个数组传参了，并且只传了一个，（第一位不能写小数，会报错）它就会把这个参数当成长度而不是值
        // var arr1 = [10];//长度为一


        //      数组的常用方法
        // 改变原数组（在原有基础上改变）
        //     push  pop  shift  unshift  sort  reseve
        //     splice
        // 数组的负一位是倒数第一位

        // push 在数组的最后一位添加数据 可以同时添加多个
        // var arr = [1, 2, 3];
        // Array.prototype.push = function() {
        //     for (var i = 0; i < arguments.length; i++) {
        //         this[this.length] = arguments[i];
        //     }
        // }
        // arr.push(4, 5);
        // console.log(arr);

        // pop 把数组的最后一位剪切出去(忽略传参)
        // var arr = [1, 2, 3];
        // console.log(arr);

        // shift  剪切掉数组的第一位
        // unshift 在数组的前面加一位


        // sort 排序
        //1.必须写俩形参
        //2.看返回值
        //   1)当返回值为负数时，前面的数放在前面
        //   2）返回值为正数时，后面的数在前
        //   3）返回值为0时，不动
        // var arr = [2, 10, 5, 20, 4, -11, 9];
        // arr.sort(function(a, b) {
        //     return b - a;降序
        //     return a - b;升序
        // });
        // console.log(arr);

        //给一个有序的数组乱序
        // Math.random()产生一个0~1之间的开区间数(不包含0和1的数)
        // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        // arr.sort(function() {
        //     return 0.5 - Math.random();
        // });
        // console.log(arr);


        // reverse  把原数组颠倒过来

        // splice  切片
        // var arr = [1, 1, 2, 2, 3, 3];
        // arr.splice(1, 3, 0, 0); //从第几位开始,截取几位，在切口处添加新的数据
        // console.log(arr);


        // 按年龄排列下面的对象
        // var qi = {
        //     name: 'daye',
        //     age: 18,
        //     sex: 'male',
        //     face: 'handsome'
        // }
        // var huang = {
        //     name: 'shulang',
        //     age: 60,
        //     sex: 'undefined',
        //     face: 'spirit'
        // }
        // var zhu = {
        //     name: 'muzhu',
        //     age: 45,
        //     sex: 'hermaphrodite',
        //     face: 'ugly'
        // }
        // var arr = [qi, huang, zhu];
        // arr.sort(function(a, b) {
        //     return a.age - b.age;
        // });
        // console.log(arr);


        // 按字节长度排序
        // function myByte(str) {
        //     var num = str.length;
        //     for (var i = 0; i < str.length; i++) {
        //         if (str.charCodeAt(i) > 255) {
        //             num++;
        //         }
        //     }
        //     return num;
        // }
        // var arr = ['huangshulang', '黄蜀郎', '老母猪abcefghijklmn', 'aoligei彩虹涛', '阿伟已经西内了', 'laomuzhu']
        // arr.sort(function(a, b) {
        //     return myByte(a) - myByte(b);
        // });
        // console.log(arr);



        // 不改变原数组  生成一个全新的数组
        // concat,join---->split,toString,slice
        // var arr = [1, 2, 3];
        // var arr1 = [4, 5, 6, 7];
        // var a = arr.concat(arr1); //把后面数组拼接到前面数组上
        // console.log(a);


        //slice(从该位开始截取，截取到该位)不写就是全部截取
        // var arr = [1, 2, 3, 4, 5];
        // var newArr = arr.slice(2, 4);
        // console.log(newArr);

        // join('必须传一个字符串')按照传的参数把数组里面的每一位都连接起来，并变成一个字符串

        // split  可以返回数组
        // var arr = [1, 2, 3, 4, 5, 6];
        // var str = arr.join('-');
        // console.log(str);
        // var num = str.split('4');
        // console.log(num);



        //            类数组
        // 1.可以利用属性名模拟数组的特性
        // 2.可以动态的增长length属性
        // 3.如果强行让类数组调用push方法，则会根据length属性值的位置进行属性的扩充
        //*DOM所能生成的所有类似于数组的东西全是类数组
        // var obj = {
        //         '0': 'a',
        //         '1': 'b',
        //         '2': 'c',
        //         'length': 3,
        //         'push': Array.prototype.push,
        //         'splice': Array.prototype.splice
        //     }
        // 属性要为索引（数字）属性，必须有length属性，最好加上push
        //好处




        // 封装type，解决typeof()返回结果不精准的问题
        // typeof([]) ===>array
        // typeof({}) ===>object
        // typeof(function) ===>object
        // typeof(new Number()) ===>number Object(num类型的包装类对象)
        // typeof(123) ===>number

        // function type(target) {
        //     var ret = typeof(target);
        //     var template = {
        //         '[object Array]': 'array',
        //         '[object Object]': 'object',
        //         '[object Number]': 'number - object',
        //         '[object Boolean]': 'boolean - object',
        //         '[object String]': 'string - object'
        //     }
        //     if (target === null) {
        //         return 'null';
        //     } else if (ret == 'object') {
        //         var str = Object.prototype.toString.call(target);
        //         return template[str];
        //     } else {
        //         return ret;
        //     }
        // }
        // console.log(type());
    </script>
</body>

</html>